home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 July / CMCD0704.ISO / Software / Freeware / Comunicatii / htttrack / httrack-3.32-2.exe / {app} / src_win / WinHTTrack / newlang.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2004-01-24  |  15.4 KB  |  573 lines
  1.  
  2. // Win includes
  3. #include "stdafx.h"
  4. #include "Shell.h"
  5. #include <comdef.h>
  6.  
  7. // Hash for lang.h
  8. extern "C" {
  9.   #include "HTTrackInterface.h"
  10. #define HTS_INTERNAL_BYTECODE
  11.   #include "htsinthash.h"
  12. #undef HTS_INTERNAL_BYTECODE
  13. };
  14. #include "newlang.h"
  15.  
  16. // test
  17. #ifndef _MBCS
  18. #error "MBCS/DBCS support not found"
  19. #endif
  20. #include <locale.h>
  21.  
  22.  
  23. int NewLangStrSz=1024;
  24. inthash NewLangStr=NULL;
  25. int NewLangStrKeysSz=1024;
  26. inthash NewLangStrKeys=NULL;
  27. UINT NewLangCP = CP_THREAD_ACP;
  28.  
  29. void LANG_LOAD(char* limit_to) {
  30.   CWaitCursor wait;
  31.   //
  32.   extern int NewLangStrSz;
  33.   extern inthash NewLangStr;
  34.   extern int NewLangStrKeysSz;
  35.   extern inthash NewLangStrKeys;
  36.   //
  37.   int selected_lang=LANG_T(-1);
  38.   //
  39.   if (!limit_to) {
  40.     LANG_DELETE();
  41.     NewLangStr=inthash_new(NewLangStrSz);
  42.     NewLangStrKeys=inthash_new(NewLangStrKeysSz);
  43.     if ((NewLangStr==NULL) || (NewLangStrKeys==NULL)) {
  44.       AfxMessageBox("Error in lang.h: not enough memory");
  45.     } else {
  46.       inthash_value_is_malloc(NewLangStr,1);
  47.       inthash_value_is_malloc(NewLangStrKeys,1);
  48.     }
  49.   }
  50.  
  51.   CString app;
  52.   CWinApp* pApp = AfxGetApp();
  53.   if (pApp) {
  54.     app=pApp->m_pszHelpFilePath;
  55.     app=app.Left(app.ReverseFind('\\')+1);
  56.   }
  57.  
  58.   /* Load master file (list of keys and internal keys) */
  59.   if (!limit_to) {
  60.     CString mname=app+"lang.def";
  61.     if (!fexist((char*)LPCTSTR(mname)))
  62.       mname="lang.def";
  63.     FILE* fp=fopen(mname,"rb");
  64.     if (fp) {
  65.       char intkey[8192];
  66.       char key[8192];
  67.       while(!feof(fp)) {
  68.         linput_cpp(fp,intkey,8000);
  69.         linput_cpp(fp,key,8000);
  70.         if (strnotempty(intkey) && strnotempty(key)) {
  71.           char* test=LANGINTKEY(key);
  72.  
  73.           /* Increment for multiple definitions */
  74.           if (strnotempty(test)) {
  75.             int increment=0;
  76.             int pos=strlen(key);
  77.             do {
  78.               increment++;
  79.               sprintf(key+pos,"%d",increment);
  80.               test=LANGINTKEY(key);
  81.             }  while (strnotempty(test));
  82.           }
  83.  
  84.           if (!strnotempty(test)) {         // Θviter doublons
  85.             // conv_printf(key,key);
  86.             int len;
  87.             char* buff;
  88.             len=strlen(intkey);
  89.             buff=(char*)malloc(len+2);
  90.             if (buff) {
  91.               strcpybuff(buff,intkey);
  92.               inthash_add(NewLangStrKeys,key,(long int)(char*)buff);
  93.             }
  94.           }
  95.         } // if
  96.       }  // while
  97.       fclose(fp);
  98.     } else {
  99.       AfxMessageBox("FATAL ERROR\r\n'lang.def' file NOT FOUND!\r\nEnsure that the installation was complete!");
  100.       exit(0);
  101.     }
  102.   }
  103.   
  104.   /* Language Name? */
  105.   char* hashname;
  106.   {
  107.     char name[256];
  108.     sprintf(name,"LANGUAGE_%d",selected_lang+1);
  109.     hashname=LANGINTKEY(name);
  110.   }
  111.  
  112.   /* Get only language name */
  113.   if (limit_to) {
  114.     if (hashname)
  115.       strcpybuff(limit_to,hashname);
  116.     else
  117.       strcpybuff(limit_to,"???");
  118.     return;
  119.   }
  120.  
  121.   /* Error */
  122.   if (!hashname)
  123.     return;
  124.  
  125.   // xxc TEST
  126.   /*
  127.   setlocale( LC_ALL, "Japanese");
  128.   _setmbcp(932);    // shift-jis
  129.   setlocale( LC_ALL, ".932" );
  130.   setlocale( LC_ALL, "[.932]" );
  131.   CString st="";
  132.   int lid=SetThreadLocale(MAKELCID(MAKELANGID(LANG_JAPANESE,SUBLANG_NEUTRAL),SORT_DEFAULT ));
  133.   */
  134.  
  135.   /* Load specific language file */
  136.   {
  137.     int loops;
  138.     CString err_msg="";
  139.     // 2nd loop: load undefined strings
  140.     for(loops=0;loops<2;loops++) {
  141.       CString lbasename;
  142.       
  143.       {
  144.         char name[256];
  145.         sprintf(name,"LANGUAGE_%d",(loops==0)?(selected_lang+1):1);
  146.         hashname=LANGINTKEY(name);
  147.       }
  148.       lbasename.Format("lang/%s.txt",hashname);
  149.       CString lname=app+lbasename;
  150.       if (!fexist((char*)LPCTSTR(lname)))
  151.         lname=lbasename;
  152.       FILE* fp=fopen(lname,"rb");
  153.       if (fp) {
  154.         char extkey[8192];
  155.         TCHAR value[8192];
  156.         while(!feof(fp)) {
  157.           //int ssz;
  158.           linput_cpp(fp,extkey,8000);
  159.           linput_cpp(fp,value,8000);
  160.           /*
  161.           ssz=linput_cpp(fp,value,8000);
  162.           CString st=value;
  163.           AfxMessageBox(st);
  164.           if (ssz>0) {
  165.             int tst=0;
  166.             int test=IsTextUnicode(value,ssz,&tst);
  167.             unsigned short st2[1024];
  168.             int ret=MultiByteToWideChar(CP_UTF8,0,(char*)value,ssz,st2,1024);
  169.             if (ret>0) {
  170.               char st3[1024]="";
  171.               int ret2=WideCharToMultiByte(CP_THREAD_ACP,0,st2,ret,(char*)st3,1024,NULL,FALSE);
  172.               if (ret2>0) {
  173.                 AfxMessageBox(st3);
  174.               }
  175.             }
  176.           }
  177.           */
  178.  
  179.           if (strnotempty(extkey) && strnotempty(value)) {
  180.             int len;
  181.             char* buff;
  182.             char* intkey;
  183.             
  184.             intkey=LANGINTKEY(extkey);
  185.             
  186.             if (strnotempty(intkey)) {
  187.               
  188.               /* Increment for multiple definitions */
  189.               {
  190.                 char* test=LANGSEL(intkey);
  191.                 if (strnotempty(test)) {
  192.                   if (loops == 0) {
  193.                     int increment=0;
  194.                     int pos=strlen(extkey);
  195.                     do {
  196.                       increment++;
  197.                       sprintf(extkey+pos,"%d",increment);
  198.                       intkey=LANGINTKEY(extkey);
  199.                       if (strnotempty(intkey))
  200.                         test=LANGSEL(intkey);
  201.                       else
  202.                         test="";
  203.                     }  while (strnotempty(test));
  204.                   } else
  205.                     intkey="";
  206.                 } else {
  207.                   if (loops > 0) {
  208.                     err_msg += intkey;
  209.                     err_msg += " ";
  210.                   }
  211.                 }
  212.               }
  213.               
  214.               /* Add key */
  215.               if (strnotempty(intkey)) {
  216.                 len=strlen(value);
  217.                 buff=(char*)malloc(len+2);
  218.                 if (buff) {
  219.                   conv_printf(value,buff);
  220.                   inthash_add(NewLangStr,intkey,(long int)(char*)buff);
  221.                 }
  222.               }
  223.               
  224.             }
  225.           } // if
  226.         }  // while
  227.         fclose(fp);
  228.       } else {
  229.         AfxMessageBox("FATAL ERROR\r\n'lang.def' file NOT FOUND!\r\nEnsure that the installation was complete!");
  230.         exit(0);
  231.       }
  232.     }
  233.     if (err_msg.GetLength()>0) {
  234.       // AfxMessageBox("Error: undefined strings follows:\r\n"+err_msg);
  235.     }
  236.   }
  237.  
  238.  
  239.  
  240. #if 0
  241.   app=app+"lang.h";
  242.   if (!fexist((char*)LPCTSTR(app)))
  243.     app="lang.h";
  244.   
  245.   FILE* fp=fopen(app,"rb");
  246.   if (fp) {
  247.     char s[8192];
  248.     while(!feof(fp)) {
  249.       linput_cpp(fp,s,8000);
  250.       if (!strncmp(s,"#define ",8)) {
  251.         char* a;
  252.         char* name=s+8;
  253.         a=name;
  254.         while((*a!=' ') && (*a)) a++;
  255.         if ((*a) && (strlen(name)>0) && (((int) a - (int) name)<64)) {
  256.           *a++='\0';
  257.           if (limit_to) {
  258.             if (strcmp(name,limit_to))
  259.               a=NULL;
  260.           }
  261.           if (a) {
  262.             char* data;
  263.             data=a;
  264.             int toggle=0;
  265.             char* start_str=NULL;
  266.             int count=0;
  267.             while(*a) {
  268.               if (*a=='\"') {
  269.                 toggle++;
  270.                 if ((toggle%2)==1) {
  271.                   if (count==selected_lang) {
  272.                     start_str=a+1;
  273.                   }
  274.                   count++;
  275.                 } else {
  276.                   if (start_str) {
  277.                     char* buff;
  278.                     int len;
  279.                     len=(int) a - (int) start_str;
  280.                     if (len) {
  281.                       buff=(char*)malloc(len+2);
  282.                       if (buff) {
  283.                         int i=0,j=0;
  284.                         buff[0]='\0';
  285.                         //strncatbuff(buff,start_str,len);
  286.                         while(i<len) {
  287.                           switch(start_str[i]) {
  288.                           case '\\': 
  289.                             i++;
  290.                             switch(start_str[i]) {
  291.                             case 'a': buff[j]='\a'; break;
  292.                             case 'b': buff[j]='\b'; break;
  293.                             case 'f': buff[j]='\f'; break;
  294.                             case 'n': buff[j]='\n'; break;
  295.                             case 'r': buff[j]='\r'; break;
  296.                             case 't': buff[j]='\t'; break;
  297.                             case 'v': buff[j]='\v'; break;
  298.                             case '\'': buff[j]='\''; break;
  299.                             case '\"': buff[j]='\"'; break;
  300.                             case '\\': buff[j]='\\'; break;
  301.                             case '?': buff[j]='\?'; break;
  302.                             default: buff[j]=start_str[i]; break;
  303.                             }
  304.                             break;
  305.                             default: 
  306.                               buff[j]=start_str[i]; 
  307.                               break;
  308.                           }
  309.                           i++;
  310.                           j++;
  311.                         }
  312.                         buff[j++]='\0';
  313.                         if (!limit_to)
  314.                           inthash_add(NewLangStr,name,(long int)(char*)buff);
  315.                         else {
  316.                           strcpybuff(limit_to,buff);
  317.                           free(buff);
  318.                           return;
  319.                         }
  320.                       }
  321.                     }
  322.                     start_str=NULL;
  323.                   }
  324.                 }
  325.               }
  326.               a++;
  327.             }
  328.           }
  329.           
  330.           //NewLangStr.SetAt(sname,st);
  331.           /*
  332.           } else {
  333.           CString info;
  334.           info.Format("Error in lang.h: %s",name);
  335.           AfxMessageBox(info);
  336.         */
  337.         }
  338.       }
  339.     }
  340.  
  341.  
  342.     fclose(fp);
  343.  
  344.   } else {
  345.     AfxMessageBox("FATAL ERROR\r\n'lang.h' file NOT FOUND!\r\nEnsure that the installation was complete!");
  346.     exit(0);
  347.   }
  348. #endif
  349.  
  350.   // Control limit_to
  351.   if (limit_to)
  352.     limit_to[0]='\0';
  353.  
  354.   // Set locale
  355.   if (!limit_to) {
  356.     CString charset = LANGUAGE_CHARSET;
  357.     charset.TrimLeft();
  358.     charset.TrimRight();
  359.     charset.MakeLower();
  360.     NewLangCP = CP_THREAD_ACP;
  361. #if 0
  362.     if (charset.GetLength() > 0) {
  363.       if (charset.Left(9) == "iso-8859-") {
  364.         int iso = 0;
  365.         int isoCP[] = {0, /* 0 */
  366.           1252, /* ISO-8859-1 */
  367.           1250, /* ISO-8859-2 */
  368.           0, /* ISO-8859-3 */
  369.           0, /* ISO-8859-4 */
  370.           1251, /* ISO-8859-5 */
  371.           1256, /* ISO-8859-6 */
  372.           1253, /* ISO-8859-7 */
  373.           1255, /* ISO-8859-8 */
  374.           1254, /* ISO-8859-9 */
  375.         };
  376.         if (sscanf(charset.GetBuffer(0) + 9, "%d", &iso) == 1) {
  377.           if (iso < sizeof(isoCP)/sizeof(isoCP[0])) {
  378.             if (isoCP[iso] != 0) {
  379.               NewLangCP = isoCP[iso];
  380.             }
  381.           }
  382.         }
  383.       } else if (charset.Left(8) == "windows-") {
  384.         int windows = 0;
  385.         if (sscanf(charset.GetBuffer(0) + 8, "%d", &windows) == 1) {
  386.           NewLangCP = windows;
  387.         }
  388.       } else if (charset == "shift-jis") {
  389.         NewLangCP = 932;
  390.       } else if (charset == "big5") {
  391.         NewLangCP = 950;
  392.       } else if (charset == "gb2312") {
  393.         NewLangCP = 936;
  394.       } else {
  395.         NewLangCP = CP_THREAD_ACP;
  396.       }
  397.     }
  398. #endif
  399.   }
  400.  
  401. }
  402.  
  403. void conv_printf(char* from,char* to) {
  404.   int i=0,j=0,len;
  405.   len=strlen(from);
  406.   while(i<len) {
  407.     switch(from[i]) {
  408.     case '\\': 
  409.       i++;
  410.       switch(from[i]) {
  411.       case 'a': to[j]='\a'; break;
  412.       case 'b': to[j]='\b'; break;
  413.       case 'f': to[j]='\f'; break;
  414.       case 'n': to[j]='\n'; break;
  415.       case 'r': to[j]='\r'; break;
  416.       case 't': to[j]='\t'; break;
  417.       case 'v': to[j]='\v'; break;
  418.       case '\'': to[j]='\''; break;
  419.       case '\"': to[j]='\"'; break;
  420.       case '\\': to[j]='\\'; break;
  421.       case '?': to[j]='\?'; break;
  422.       default: to[j]=from[i]; break;
  423.       }
  424.       break;
  425.       default: 
  426.         to[j]=from[i]; 
  427.         break;
  428.     }
  429.     i++;
  430.     j++;
  431.   }
  432.   to[j++]='\0';
  433. }
  434.  
  435. void LANG_DELETE() {
  436.   extern int NewLangStrSz;
  437.   extern inthash NewLangStr;
  438.   extern int NewLangStrKeysSz;
  439.   extern inthash NewLangStrKeys;
  440.   //
  441.   inthash_delete(&NewLangStr);
  442.   inthash_delete(&NewLangStrKeys);
  443. }
  444.  
  445. // sΘlection de la langue
  446. void LANG_INIT() {
  447.   CWinApp* pApp = AfxGetApp();
  448.   if (pApp) {
  449.     int test = pApp->GetProfileInt("Language","IntId",0);
  450.     LANG_T(pApp->GetProfileInt("Language","IntId",0));
  451.   }
  452. }
  453.  
  454. int LANG_T(int l) {
  455.   if (l>=0) {
  456.     QLANG_T(l);
  457.     CWinApp* pApp = AfxGetApp();
  458.     if (pApp)
  459.       pApp->WriteProfileInt("Language","IntId",l);
  460.     LANG_LOAD(NULL);
  461.   }
  462.   return QLANG_T(-1);  // 0=default (english)
  463. }
  464.  
  465. int QLANG_T(int l) {
  466.   static int lng=0;
  467.   if (l>=0) {
  468.     lng=l;
  469.   }
  470.   return lng;  // 0=default (english)
  471. }
  472.  
  473.  
  474. /*
  475. char* LANGSEL(char* lang0,...) {
  476.   char* lang=lang0;
  477.   char* langalt="";
  478.   int langid=LANG_T(-1);
  479.   //
  480.   va_list argList;
  481.     va_start(argList, lang0);
  482.   while(langid>0) {
  483.     if (lang) {
  484.       if (strlen(langalt)==0) {
  485.         if (strlen(lang)>0)
  486.           langalt=lang;
  487.       }
  488.     }
  489.     langid--;
  490.     lang=va_arg(argList, char*);
  491.   }
  492.   va_end(argList);
  493.   //
  494.   if (!lang)
  495.     return langalt;
  496.   if (strlen(lang)==0)
  497.     return langalt;
  498.   return lang;
  499. }
  500. */
  501.  
  502. char* LANGSEL(char* name) {
  503.   unsigned long int adr=NULL;
  504.   if (NewLangStr)
  505.   if (!inthash_read(NewLangStr,name,(long int *)&adr))
  506.     adr=NULL;
  507.   if (adr) {
  508.     return (char*)adr;
  509.   }
  510.   return "";
  511. }
  512.  
  513. char* LANGINTKEY(char* name) {
  514.   unsigned long int adr=NULL;
  515.   if (NewLangStrKeys)
  516.   if (!inthash_read(NewLangStrKeys,name,(long int *)&adr))
  517.     adr=NULL;
  518.   if (adr) {
  519.     return (char*)adr;
  520.   }
  521.   return "";
  522. }
  523.  
  524. static _bstr_t ConvertCodepage(LPCSTR str, UINT codePage)
  525. {
  526.   _bstr_t returnValue;
  527.   BOOL ok = TRUE;
  528.   int mbLength = strlen(str);
  529.   int wideLength = ::MultiByteToWideChar( codePage, 0, str, mbLength, NULL, NULL); 
  530.   if (wideLength > 0) 
  531.   {
  532.     wchar_t *wcharBuffer = new wchar_t[wideLength+1]; 
  533.     ::MultiByteToWideChar( codePage, 0, str, mbLength, wcharBuffer, wideLength); 
  534.     wcharBuffer[wideLength] = '\0';
  535.     returnValue = wcharBuffer;
  536.     delete wcharBuffer;
  537.   }
  538.   return returnValue;
  539. }
  540.  
  541. BOOL SetDlgItemTextCP(HWND hDlg, int nIDDlgItem, LPCSTR lpString) {
  542.   if (NewLangCP != CP_THREAD_ACP)
  543.     return SetDlgItemTextW(hDlg, nIDDlgItem, ConvertCodepage(lpString, NewLangCP));
  544.   else
  545.     return SetDlgItemTextA(hDlg, nIDDlgItem, lpString);
  546. }
  547.  
  548. BOOL SetDlgItemTextCP(CWnd* wnd, int nIDDlgItem, LPCSTR lpString) {
  549.   return SetDlgItemTextCP(wnd->m_hWnd, nIDDlgItem, lpString);
  550. }
  551.  
  552. BOOL SetWindowTextCP(HWND hWnd, LPCSTR lpString) {
  553.   if (NewLangCP != CP_THREAD_ACP)
  554.     return SetWindowTextW(hWnd, ConvertCodepage(lpString, NewLangCP));
  555.   else
  556.     return SetWindowTextA(hWnd, lpString);
  557. }
  558.  
  559. BOOL SetWindowTextCP(CWnd* wnd, LPCSTR lpString) {
  560.   return SetWindowTextCP(wnd->m_hWnd, lpString);
  561. }
  562.  
  563. BOOL ModifyMenuCP(HMENU hMnu, UINT uPosition, UINT uFlags, UINT uIDNewItem, LPCSTR lpNewItem) {
  564.   if (NewLangCP != CP_THREAD_ACP)
  565.     return ModifyMenuW(hMnu, uPosition, uFlags, uIDNewItem, ConvertCodepage(lpNewItem, NewLangCP));
  566.   else
  567.     return ModifyMenuA(hMnu, uPosition, uFlags, uIDNewItem, lpNewItem);
  568. }
  569.  
  570. BOOL ModifyMenuCP(CMenu* menu, UINT uPosition, UINT uFlags, UINT uIDNewItem, LPCSTR lpNewItem) {
  571.   return ModifyMenuCP(menu->m_hMenu, uPosition, uFlags, uIDNewItem, lpNewItem);
  572. }
  573.